package com.adhere.system.controller;

import com.adhere.system.pojo.RbacRole;
import com.adhere.system.pojo.RbacUserRole;
import com.adhere.system.pojo.dto.RolePrivilegeDto;
import com.adhere.system.pojo.vo.PageVo;
import com.adhere.system.pojo.vo.RoleVo;
import com.adhere.system.service.IRbacRolePrivilegeService;
import com.adhere.system.service.IRbacRoleService;
import com.adhere.system.service.IRbacUserRoleService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * 角色管理
 */
@RestController
@RequestMapping("/roles")
public class RoleController {

    @Autowired
    private IRbacRoleService roleService;

    @Autowired
    private IRbacUserRoleService userRoleService;

    @Autowired
    private IRbacRolePrivilegeService rolePrivilegeService;

    /**
     * 根据角色名称,查询所有的角色信息
     * @param roleName 角色名称
     * @return 角色列表信息
     */
    @GetMapping("/")
    public List<RbacRole> getRoleList(String roleName) {
        QueryWrapper<RbacRole> queryWrapper = new QueryWrapper<>();
        if (StringUtils.hasText(roleName)) {
            queryWrapper.like("name", roleName);
        }
        return roleService.list(queryWrapper);
    }

    /**
     * 根据角色名称分页查询角色列表
     * @param currentPage 当前页,默认是1
     * @param pageSize 每页显示条数,默认是10
     * @param name 角色名称
     * @return 角色的列表信息
     */
    @GetMapping("/page")
    public PageVo<RbacRole> getRolePage(@RequestParam(required = false, defaultValue = "1")Integer currentPage,
                                        @RequestParam(required = false, defaultValue = "10") Integer pageSize,
                                        @RequestParam(required = false) String name) {
        return roleService.getRolePage(currentPage,pageSize,name);
    }

    /**
     * 根据角色编码删除角色
     * @param roleCode 角色编码
     */
    @DeleteMapping("/{roleCode}")
    public void deleteRole (@PathVariable String roleCode) {

        // 校验是否还有关联的用户
        List<RbacUserRole> userRoleList = userRoleService.selectByRoleCode(roleCode);
        if (!userRoleList.isEmpty()) {
            throw new IllegalArgumentException("此角色还在被用户使用中,请先解除绑定关系");
        }

        // 级联删除此用户下的权限信息
        rolePrivilegeService.deleteByRoleCode(roleCode);
        QueryWrapper<RbacRole> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("code", roleCode);
        roleService.remove(queryWrapper);

    }

    /**
     * 新增角色， 可以传递权限列表也可以不传递
     * @param role 角色的实体类
     * @param privilegeCodeList 权限的Code的列表
     */
    @PostMapping("/")
    public void addRole (@RequestBody @Validated RbacRole role,
                         @RequestParam(required = false) List<String> privilegeCodeList) {
        roleService.addRole(role, privilegeCodeList);
    }

    /**
     * 使用userCode 查询指定用户的角色列表
     * @param userCode 用户编码
     * @return 角色列表
     */
    @GetMapping("/{userCode}")
    public List<RbacRole> getRoleListByUserCode (@PathVariable String userCode) {
        return roleService.getRoleListByUserCode(userCode);
    }

    /**
     * 更新角色下的权限列表
     * @param rolePrivilegeDto 角色权限实体类对象
     */
    @PutMapping("/privilege")
    public void updateRolePrivilege (@RequestBody @Validated RolePrivilegeDto rolePrivilegeDto) {
        roleService.updateRolePrivilege(rolePrivilegeDto);
    }

    /**
     * 更新角色信息以及角色下的权限信息
     * @param rolePrivilegeDto 角色权限的实体类对象
     */
    @PutMapping("/privilege/detail")
    public void updateRoleDetail (@RequestBody @Validated RolePrivilegeDto rolePrivilegeDto) {
        String roleName = rolePrivilegeDto.getRoleName();
        String roleCode = rolePrivilegeDto.getRoleCode();
        QueryWrapper<RbacRole> queryWrapper = new QueryWrapper<>();
        queryWrapper.ne("code", roleCode);
        queryWrapper.eq("name", roleName);
        RbacRole roleRepeat = roleService.getOne(queryWrapper);
        if (roleRepeat != null) {
            throw new IllegalArgumentException("角色名称已经存在！");
        }
        UpdateWrapper<RbacRole> updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("code", roleCode);
        updateWrapper.set("name", roleName);
        updateWrapper.set("description", rolePrivilegeDto.getRoleDescription());
        roleService.update(updateWrapper);
        roleService.updateRolePrivilege(rolePrivilegeDto);
    }

    /**
     * 根据角色code查询角色的详细信息包含角色下的权限信息
     * @param roleCode 角色编码
     * @return RoleVo 角色以及角色下的权限信息
     */
    @GetMapping("/detail/{roleCode}")
    public RoleVo getRoleDetailByRoleCode (@PathVariable String roleCode) {
        Assert.notNull(roleCode, "角色编码不能为空");
        return roleService.getRoleDetailByRoleCode(roleCode);
    }

    /**
     * 根据角色code查询角色信息  编辑页面回显使用
     * @param roleCode 角色code
     * @return RbacRole 角色信息
     */
    @GetMapping("/one/{roleCode}")
    public RbacRole getRoleByRoleCode (@PathVariable String roleCode) {
        QueryWrapper<RbacRole> queryWrapper = new QueryWrapper<>();
        if (StringUtils.hasText(roleCode)) {
            queryWrapper.eq("code", roleCode);
        }
        return roleService.getOne(queryWrapper);
    }

}
